home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Almathera Ten Pack 3: CDPD 3
/
Almathera Ten on Ten - Disc 3: CDPD3.iso
/
scope
/
201-220
/
scopedisk215
/
listcom
/
listcom.c
< prev
next >
Wrap
C/C++ Source or Header
|
1995-03-19
|
13KB
|
378 lines
;/*
; *************************************************************************
; * List Comment Created: August 11, 1991 *
; * ©1991 John Bianchi Bianchi Computer Systems *
; *************************************************************************
; * Execute me to compile under SAS/C 5.10a *
; *************************************************************************
if NOT exists PatMatch.o
lc -tr PatMatch.c
endif
lc -tr ListCom.c
blink FROM LIB:c.o+"ListCom.o"+"PatMatch.o" TO "ListCom" LIB LIB:lc.lib LIB:amiga.lib
quit
*/
#include <libraries/dos.h>
#include <libraries/dosextens.h>
#include <exec/types.h>
#include <exec/memory.h>
#include <string.h>
#define PROGRAM "ListCom"
#define VERS "1.33"
#define RELEASE "18.10.1991"
#define COPYRIGHT "©1991 John Bianchi All Rights Reserved."
/* 2.0 compatable Version Tag String */
UBYTE *version = "\0$VER: List Comments " VERS " (17.10.91) ";
UBYTE *Usage = "\
LIST COMMENTS
Version: " VERS " " COPYRIGHT "
\n\
\n\
Usage:
\n
" PROGRAM "
<Path> <Comment> <-options>\n\
\n\
With:
\n\
Path : the path and/or file(s) you want to list\n\
Comment : the comment(s) you want to match\n\n\
Options:
\n\
-M = Match : stop on first found match\n\
-F = NoForm : don't format the output listing\n\
-H = NoHead : do not show header line\n\
-S = NoSize : don't show file size(s)\n\
-C = NoCom : don't show file comment(s)\n\
-Q = Quiet : (-H -S -C -F) only show the file name(s)\n\
-N = NoLine : don't do a line feed (-m)\n\
\n";
struct FileInfoBlock *f_info;
int ListCom(); /* Parses and does directory type stuff */
int showfileinfo(); /* shows a file info block in special format(s) */
BOOL isapat(); /* checks for pattern characters */
BOOL patternmatch(); /* calls PatMatch.c funcs, returns TRUE/FALSE */
char err_msg[80]; /* My error messages */
int return_value; /* depends upon return of ListCom() routine */
char Pat[128]; /* here for PatMatch.c stuff written/translated */
char Str[128]; /* by Jeff Lydiatt */
WORD Aux[128]; /* See PatMatch.c source for more info */
/* flags for the argument switches */
BOOL match,nohead,noform,nosize,nocom,noline = FALSE;
main (argc, argv)
int argc;
char *argv[];
{
char filepath[255], filenote[80];
int k,error;
struct Process *proc;
struct CommandLineInterface *cli;
proc = (struct Process *)FindTask(NULL);
cli = (struct CommandLineInterface *)(proc->pr_CLI << 2);
if(!cli || argc == 0) exit(RETURN_ERROR);
if((f_info=(struct FileInfoBlock *)
AllocMem(sizeof(struct FileInfoBlock),MEMF_CHIP|MEMF_CLEAR))==0)
{
printf("%s Can't Allocate Memory!",argv[0]);
exit(RETURN_FAIL);
}
/* if no arguments supplied or the user type ? show usage */
/* Will probably use the 2.0 template stuff after 2.0 */
/* is the OS of choice. (and i see some clean, small source */
/* code that I can learn it from! */
if(argv[1][0]=='?')
{
printf("%s",Usage);
exit(RETURN_WARN);
}
/* if not given, we must initialize */
filepath[0] = '\0';
filenote[0] = '\0';
/* This is the Argument parsing stuff */
for(k=1; k<argc; k++)
{
/* this is to find the '-' commands */
if(argv[k][0] == '-')
{
switch( argv[k][1] )
{
case 'N':
case 'n':
noline=TRUE;
case 'm':
case 'M':
match=TRUE;
break;
case 'Q':
case 'q':
nohead=TRUE;
nosize=TRUE;
nocom=TRUE;
case 'f':
case 'F':
noform=TRUE;
break;
case 'H':
case 'h':
nohead=TRUE;
break;
case 'S':
case 's':
nosize=TRUE;
break;
case 'C':
case 'c':
nocom=TRUE;
case '\0' /* so a '-' alone will be ignored */
break; /* ignore the compiler warning */
default:
printf("\nUnknown command: %s\n",argv[k]);
exit(RETURN_ERROR);
}
}
else
{
/* this puts the 1st and 2nd argument into their variables */
switch( k )
{
case 1:
strcpy(filepath, argv[k]);
break;
case 2:
strcpy(filenote, argv[k]);
break;
default:
printf("\nUnknown command: (%d) \"%s\"\n",k,argv[k]);
exit(RETURN_ERROR);
}
}
}
/********************************************************************/
/* ok, here we send the path and note to be searched. */
/* ListCom() should definately be cleaned up, but this part of the */
/* code will remain the same. ListCom() returns an int value of the*/
/* error encountered. err_msg[] will have the error message for */
/* a returned value of -1. */
/********************************************************************/
switch( error = ListCom(filepath,filenote) )
{
case 0:
return_value = RETURN_OK; /* listed something */
break;
case 1:
return_value = RETURN_WARN; /* didn't match included for */
break; /* script usage */
case -1:
return_value = RETURN_ERROR; /* some kinda error */
printf("ListCom Error: %s.\n",err_msg);
break;
default:
return_value = error; /* AimgaDOS error */
printf("AmigaDOS Error: %d\n",error);
break;
}
FreeMem(f_info,sizeof(struct FileInfoBlock));
exit(return_value);
}
int ListCom(filepath, filenote)
char *filepath,*filenote;
{
int i,error = 0;
int showd = 1;
long lock;
char patternpath[80],patternfile[80];
BOOL name_patmatch=FALSE;
lock = Lock(filepath, ACCESS_READ);
/* have to do this as I don't know any other way! */
if(!lock) if(isapat(filepath))
{
strcpy(patternpath,filepath);
/* patternpath is a copy of filepath, let's remove the file
portion */
for(i=(strlen(patternpath));i>=0;i--)
{
if(patternpath[i] == ':' || patternpath[i] == '/')
break;
else
patternpath[i] = '\0';
}
/* put the patterned file info into patternfile */
/* if any path exists from above, pull filename part */
if(strlen(patternpath)>0)
{
error=strmid(filepath,patternfile,i+2,30);
if(error) /* not sure why this would come up, but... */
{
strcpy(err_msg,"Error in internal string manipulation");
return(-1);
}
/* We're only here to pattern match the last node of the
filepath. ie: DH0:#?/test <- Not allowed! (Maybe I'll
get that in a later version when I learn more) */
if(isapat(patternpath))
{
strcpy(err_msg,"Can't pattern match the Path!");
return(-1);
}
}
else
strcpy(patternfile,filepath);
/* patternpath is really the path part of the argument, it
will not use any wildcards, only "" for current dir. */
lock=Lock(patternpath, ACCESS_READ);
if(!lock)
{
strcpy(err_msg,"`");
strcat(err_msg,patternpath);
strcat(err_msg,"' path not found");
return(-1);
}
name_patmatch=TRUE;
}
else /* failed orig lock and did not have any wildcards */
{
strcpy(err_msg,"`");
strcat(err_msg,filepath);
strcat(err_msg,"' file not found");
return(-1);
}
if((Examine(lock,f_info))==0)
{
strcpy(err_msg,"Unknown File"); /* this should never happen */
return(-1);
}
if(f_info->fib_DirEntryType > 0) /* original lock is a Directory!! */
{
if(!nohead)
printf("Listing of directory: \"%s\"\n",f_info->fib_FileName);
/* Loop to read entries in directory */
while ((ExNext(lock,f_info))!=0)
{
/* if were listing the whole directory or parrern matching
a filename */
if(!name_patmatch || patternmatch(patternfile,f_info->fib_FileName))
{
/* is there a filenote to check? */
if(strlen(filenote)>0)
{
/* yes, so see if it is a pattern match to the
current file entry's comment */
if(patternmatch(filenote,f_info->fib_Comment)>0)
{
showd=showfileinfo();
if(match) break;
}
}
else /* no filenote, so show all files with comments */
if(strlen(f_info->fib_Comment)>0)
{
showd=showfileinfo();
if(match) break;
}
}
}
}
else /* well, we were given a file name, it exists, so show it! */
{
if(!name_patmatch || patternmatch(patternfile,f_info->fib_FileName))
showd=showfileinfo();
}
UnLock(lock);
error = IoErr();
if(error = ERROR_NO_MORE_ENTRIES)
return(showd); /* ignore No more entries and send if we matched */
else
return(error); /* was an AmigaDOS errorx is IoErr() */
}
/* Too much junk to put this in the ListCom() function. */
/* This function ALWAYS returns 0 = TRUE. */
/* It is not BOOL due to the nature of the return value which in */
/* turn may be used as the return value of ListCom(), this in turn */
/* lets main() know how to exit() ie: RETURN_OK, _WARN, _ERROR, _FAIL */
int showfileinfo(void)
{
{
if(noform)
printf("%s",f_info->fib_FileName);
else
printf("%-20s",f_info->fib_FileName);
if(!nosize)
{
if(f_info->fib_DirEntryType > 0 )
if(noform) printf(" Dir");
else printf(" Dir");
else
if(noform) printf(" %d",f_info->fib_Size);
else printf(" %7ld",f_info->fib_Size);
}
if(!nocom)
if(noform) printf(" %s",f_info->fib_Comment);
else printf(" \"%s\"",f_info->fib_Comment);
}
if(!noline)
printf("\n");
return(0);
}
/* I tried to write this in obscure C (you know, tight, compact,
un-intelligable) but couldn't get it to work, so this fatter
version will have to work till I can rewrite it */
BOOL isapat(str)
char *str;
{
int i;
BOOL flag=FALSE;
for(i=0; i<strlen(str); i++)
{
switch( str[i] )
{
case '#': flag=TRUE;
case '?': flag=TRUE;
default : break;
}
}
return(flag);
}
/* this is just a pre-patternmatching function to call */
/* the functions in PatMatch.c See PatMatch.c for more */
BOOL patternmatch(this,that)
char *this,*that;
{
strcpy(Pat,this);
strcpy(Str,that);
if ( CmplPat( Pat, Aux ) == 0 )
{
strcpy(err_msg,"Bad Wildcard Expression");
return(FALSE);
}
if ( Match( Pat, Aux, Str ) == 1 )
return(TRUE);
else
return(FALSE);
}